home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / cacheable.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.7 KB  |  327 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. __metaclass__ = type
  6. from primitives import autoassign, Storage as S
  7. from introspect import base_classes
  8. import stdpaths
  9. import httplib2
  10. from logging import getLogger
  11. log = getLogger('cacheable')
  12. info = log.info
  13. from os.path import split as pathsplit, exists as pathexists, join as pathjoin
  14. import os
  15. import sys
  16. import traceback
  17. from zlib import compress, decompress
  18. import cPickle
  19. _cacheattr = '__cached'
  20.  
  21. def save_cache_object(name, obj, user = False):
  22.     
  23.     try:
  24.         f = _[2]
  25.         f.write(compress(cPickle.dumps(obj)))
  26.     finally:
  27.         pass
  28.  
  29.  
  30.  
  31. def load_cache_object(name, user = False):
  32.     p = get_cache_root(user) / name
  33.     if not p.exists():
  34.         return None
  35.     
  36.     
  37.     try:
  38.         f = _[2]
  39.         return cPickle.loads(decompress(f.read()))
  40.     finally:
  41.         pass
  42.  
  43.  
  44.  
  45. def get_cache_root(user = False):
  46.     root = stdpaths.userlocaldata / 'cache'
  47.     if user:
  48.         profile = profile
  49.         import common
  50.         if profile:
  51.             name = profile.username
  52.         else:
  53.             name = ''
  54.         root = root / (name + '_cache')
  55.     
  56.     return root
  57.  
  58.  
  59. def get_obj_cache_path(obj, user = False):
  60.     ocp = getattr(obj, 'cache_path', '')
  61.     if not ocp:
  62.         import warnings
  63.         warnings.warn('%r does not have a cache path, you really should give it one.' % obj)
  64.     
  65.     return get_cache_root(user) / ocp
  66.  
  67.  
  68. def clear_file_cache(obj, user = False):
  69.     return os.remove(get_obj_cache_path(obj, user = user))
  70.  
  71.  
  72. def load_file_cache(obj, user = False):
  73.     cache_path = get_obj_cache_path(obj, user)
  74.     if not pathexists(cache_path):
  75.         return None
  76.     
  77.     
  78.     try:
  79.         f = _[2]
  80.         return f.read()
  81.     finally:
  82.         pass
  83.  
  84.  
  85.  
  86. def save_file_cache(obj, data, user = False):
  87.     cache_path = get_obj_cache_path(obj, user)
  88.     cache_head = pathsplit(cache_path)[0]
  89.     if not pathexists(cache_head):
  90.         os.makedirs(cache_head)
  91.     
  92.     
  93.     try:
  94.         f = _[2]
  95.         f.write(data)
  96.     finally:
  97.         pass
  98.  
  99.  
  100.  
  101. class cproperty:
  102.     
  103.     def __init__(self, default = sentinel, box = None, unbox = None, user = False):
  104.         self.default = default
  105.         if box is not None:
  106.             self.box = box
  107.             self.unbox = unbox
  108.         else:
  109.             self.box = self.unbox = (lambda o: o)
  110.         self.usermode = user
  111.  
  112.     
  113.     def load_cache(self, obj):
  114.         data = load_file_cache(obj, self.usermode)
  115.         if hasattr(obj, 'cache_crypt'):
  116.             if data is not None:
  117.                 
  118.                 try:
  119.                     data = obj.cache_crypt[1](data)
  120.                 except Exception:
  121.                     e = None
  122.                     traceback.print_exc()
  123.                     print repr(data), repr(e)
  124.                 except:
  125.                     None<EXCEPTION MATCH>Exception
  126.                 
  127.  
  128.             None<EXCEPTION MATCH>Exception
  129.         
  130.         
  131.         try:
  132.             boxed = None if data is not None else { }
  133.         except Exception:
  134.             e = None
  135.             traceback.print_exc()
  136.             boxed = { }
  137.  
  138.         cache = { }
  139.         error = False
  140.         for k, v in boxed.iteritems():
  141.             
  142.             try:
  143.                 cache.update({
  144.                     k: self.cacheprop(obj, k).unbox(v) })
  145.             continue
  146.             except Exception:
  147.                 traceback.print_exc()
  148.                 error = True
  149.                 continue
  150.             
  151.  
  152.         
  153.         if error:
  154.             log.warning('error retreiving cache for %s', obj)
  155.         
  156.         setattr(obj, _cacheattr, cache)
  157.         return cache
  158.  
  159.     
  160.     def save_cache(self, obj):
  161.         cache = getattr(obj, _cacheattr)
  162.         boxed = (None, dict)((lambda .0: for k, v in .0:
  163. (k, self.cacheprop(obj, k).box(v)))(cache.iteritems()))
  164.         compressed = compress(cPickle.dumps(boxed))
  165.         if hasattr(obj, 'cache_crypt'):
  166.             compressed = obj.cache_crypt[0](compressed)
  167.         
  168.         save_file_cache(obj, compressed, self.usermode)
  169.  
  170.     
  171.     def __get__(self, obj, objtype):
  172.         cache = getattr(obj, _cacheattr, sentinel)
  173.         if cache is sentinel:
  174.             
  175.             try:
  176.                 cache = self.load_cache(obj)
  177.             except Exception:
  178.                 traceback.print_exc()
  179.                 msg = 'error when getting cached attribute %s of %r' % (self.name(objtype), obj)
  180.                 print >>sys.stderr, msg
  181.                 cache = { }
  182.             except:
  183.                 None<EXCEPTION MATCH>Exception
  184.             
  185.  
  186.         None<EXCEPTION MATCH>Exception
  187.         name = self.name(objtype)
  188.         
  189.         try:
  190.             val = cache[name]
  191.         except KeyError:
  192.             
  193.             try:
  194.                 val = self.default()
  195.             except (AttributeError, TypeError):
  196.                 val = self.default
  197.  
  198.             if val is not sentinel:
  199.                 cache[name] = val
  200.             
  201.         except:
  202.             val is not sentinel
  203.  
  204.         if val is sentinel:
  205.             raise AttributeError
  206.         
  207.         return val
  208.  
  209.     
  210.     def name(self, objtype):
  211.         
  212.         try:
  213.             return self._name
  214.         except:
  215.             bases = [
  216.                 objtype] + base_classes(objtype)
  217.             for clz in bases:
  218.                 for k, v in clz.__dict__.iteritems():
  219.                     if v is self:
  220.                         self._name = k
  221.                         return k
  222.                         continue
  223.                 
  224.             
  225.  
  226.         raise AssertionError, str(bases)
  227.  
  228.     
  229.     def cacheprop(cls, objtype, name):
  230.         objtype = objtype.__class__
  231.         
  232.         try:
  233.             return vars(objtype)[name]
  234.         except:
  235.             bases = base_classes(objtype)
  236.             for base in bases:
  237.                 
  238.                 try:
  239.                     return vars(base)[name]
  240.                 continue
  241.                 except KeyError:
  242.                     continue
  243.                 
  244.  
  245.             
  246.  
  247.         raise AssertionError, 'cannot find %s in %s' % (name, objtype)
  248.  
  249.     cacheprop = classmethod(cacheprop)
  250.     
  251.     def __set__(self, obj, value):
  252.         cache = getattr(obj, _cacheattr, sentinel)
  253.         if cache is sentinel:
  254.             
  255.             try:
  256.                 cache = self.load_cache(obj)
  257.             except Exception:
  258.                 e = None
  259.                 traceback.print_exc()
  260.                 print >>sys.stderr, 'error loading cache for %r while setting value %s' % (obj, self.name(obj.__class__))
  261.                 cache = { }
  262.             except:
  263.                 None<EXCEPTION MATCH>Exception
  264.             
  265.  
  266.         None<EXCEPTION MATCH>Exception
  267.         cache[self.name(obj.__class__)] = value
  268.         
  269.         try:
  270.             self.save_cache(obj)
  271.         except Exception:
  272.             e = None
  273.             traceback.print_exc()
  274.             print >>sys.stderr, 'error saving cache for %r while setting value %s' % (obj, self.name(obj.__class__))
  275.  
  276.  
  277.     
  278.     def __delete__(self, obj):
  279.         self.fdel(obj)
  280.  
  281.  
  282.  
  283. class Buddy:
  284.     
  285.     def __init__(self, name, protocol):
  286.         autoassign(self, locals())
  287.  
  288.     
  289.     def cache_path(self):
  290.         proto = self.protocol
  291.         return pathjoin(proto.name, proto.username, self.name) + '.dat'
  292.  
  293.     cache_path = property(cache_path)
  294.     remote_alias = cproperty(5)
  295.  
  296.  
  297. def urlcacheopen(url, *a, **k):
  298.     http = httplib2.Http(cache = unicode(get_cache_root() / 'webcache'))
  299.     (resp, content) = http.request(url, *a, **k)
  300.     log.debug('%s for %s', resp.status, url)
  301.     return (resp, content)
  302.  
  303. if __name__ == '__main__':
  304.     import wx
  305.     app = wx.PySimpleApp()
  306.     b = Buddy('Joe', S(name = 'aim', username = 'digsby01'))
  307.     print b.remote_alias
  308.     b.remote_alias = 'network alias'
  309.     
  310.     class Foo(dict):
  311.         pass
  312.  
  313.     
  314.     class TestAble(object):
  315.         
  316.         def cache_path(self):
  317.             return 'testable.dat'
  318.  
  319.         cache_path = property(cache_path)
  320.         uids = cproperty(Foo, box = dict, unbox = Foo)
  321.  
  322.     t = TestAble()
  323.     print t.uids
  324.     t.uids[0] = 'sdfasd'
  325.     print t.uids
  326.  
  327.